const dayjs = require('dayjs');
/**
 * 任务模块Store
 * 使用MobX管理任务相关状态
 */

import { observable, action, computed } from 'mobx-miniprogram';
import { cloudHelper, Cache, dataFilterHelper } from '../../helpers/index.js';

// 缓存配置
const CACHE_KEY = 'TASK';
const CACHE_TIME = 30 * 60 * 1000; // 30分钟缓存过期

// API路由
const API = {
  LIST: 'task/list',
  DETAIL: 'task/detail',
  ADD: 'task/add',
  EDIT: 'task/edit',
  DELETE: 'task/delete',
  STATUS: 'task/status'
};

// 任务状态
export const TASK_STATUS = {
  PENDING: 0,    // 待处理
  PROCESSING: 1, // 处理中
  COMPLETED: 2,  // 已完成
  CANCELED: 3,   // 已取消
  ALL: null      // 全部状态
};

// 优先级
export const PRIORITY_LEVEL = {
  LOW: 0,        // 低
  NORMAL: 1,     // 中
  HIGH: 2,       // 高
  URGENT: 3      // 紧急
};

/**
 * 任务Store
 */
export const taskStore = observable({
  // 模块名称，用于错误处理
  moduleName: 'task',
  
  // ==== 状态数据 ====
  
  // 任务列表
  list: [],
  
  // 当前任务
  current: null,
  
  // 过滤条件
  filter: {
    status: null,
    keyword: '',
    startDate: null,
    endDate: null,
    priorityLevel: null,
    assignee: null,
    category: null,
    dateRange: null,
    searchFields: ['title', 'description', 'tags', 'assigneeName']
  },
  
  // 排序
  sort: {
    field: 'createTime',
    order: 'desc'
  },
  
  // 分页数据
  pagination: {
    page: 1,
    size: 20,
    total: 0,
    hasMore: true
  },
  
  // 加载状态
  loading: {
    list: false,
    detail: false,
    submit: false,
    operation: false
  },
  
  // 错误信息
  error: null,
  
  // 缓存信息
  cache: {
    lastUpdate: null,
    isExpired: false,
    autoRefreshInterval: 5 * 60 * 1000 // 5分钟自动刷新
  },
  
  // ==== 计算属性 ====
  
  /**
   * 是否为空数据
   */
  get isEmpty() {
    return this.list.length === 0;
  },
  
  /**
   * 当前是否有数据加载中
   */
  get isLoading() {
    return Object.values(this.loading).some(status => status === true);
  },
  
  /**
   * 是否有筛选条件
   */
  get hasFilter() {
    return this.filter.status !== null || 
           this.filter.keyword !== '' || 
           (this.filter.dateRange && this.filter.dateRange.length === 2) ||
           this.filter.priorityLevel !== null ||
           this.filter.assignee !== null ||
           this.filter.category !== null;
  },
  
  /**
   * 过滤后的任务列表
   */
  get filteredList() {
    // 如果列表为空，直接返回空数组
    if (this.isEmpty) return [];
    
    // 使用辅助工具过滤任务列表
    let filtered = [...this.list];
    
    // 状态过滤
    if (this.filter.status !== null) {
      filtered = dataFilterHelper.filterByStatus(filtered, this.filter.status);
    }
    
    // 关键词过滤
    if (this.filter.keyword) {
      filtered = dataFilterHelper.filterByKeyword(filtered, this.filter.keyword, this.filter.searchFields);
    }
    
    // 日期范围过滤
    if (this.filter.dateRange && this.filter.dateRange.length === 2) {
      filtered = dataFilterHelper.filterByDateRange(filtered, this.filter.dateRange, 'createTime');
    }
    
    // 优先级过滤
    if (this.filter.priorityLevel !== null) {
      filtered = filtered.filter(task => task.priorityLevel === this.filter.priorityLevel);
    }
    
    // 指派人过滤
    if (this.filter.assignee) {
      filtered = filtered.filter(task => task.assignee === this.filter.assignee);
    }
    
    // 分类过滤
    if (this.filter.category) {
      filtered = filtered.filter(task => task.category === this.filter.category);
    }
    
    // 应用排序
    return dataFilterHelper.sortList(filtered, this.sort.field, this.sort.order);
  },
  
  /**
   * 按状态分组的任务
   */
  get tasksByStatus() {
    // 如果列表为空，返回空对象
    if (this.isEmpty) {
      return {
        [TASK_STATUS.PENDING]: [],
        [TASK_STATUS.PROCESSING]: [],
        [TASK_STATUS.COMPLETED]: [],
        [TASK_STATUS.CANCELED]: []
      };
    }
    
    // 按状态分组
    const result = {};
    
    // 初始化所有状态的空数组
    Object.values(TASK_STATUS).forEach(status => {
      if (status !== null) { // 排除ALL
        result[status] = [];
      }
    });
    
    // 将任务分配到对应状态组
    this.list.forEach(task => {
      const status = task.status;
      if (result[status]) {
        result[status].push(task);
      }
    });
    
    return result;
  },
  
  /**
   * 待处理任务
   */
  get pendingTasks() {
    return this.list.filter(task => task.status === TASK_STATUS.PENDING);
  },
  
  /**
   * 处理中任务
   */
  get processingTasks() {
    return this.list.filter(task => task.status === TASK_STATUS.PROCESSING);
  },
  
  /**
   * 已完成任务
   */
  get completedTasks() {
    return this.list.filter(task => task.status === TASK_STATUS.COMPLETED);
  },
  
  /**
   * 已取消任务
   */
  get canceledTasks() {
    return this.list.filter(task => task.status === TASK_STATUS.CANCELED);
  },
  
  /**
   * 紧急任务
   */
  get urgentTasks() {
    return this.list.filter(task => 
      task.priorityLevel === PRIORITY_LEVEL.URGENT && 
      task.status !== TASK_STATUS.COMPLETED && 
      task.status !== TASK_STATUS.CANCELED
    );
  },
  
  /**
   * 今日任务
   */
  get todayTasks() {
    const today = dayjs().startOf('day');
    return this.list.filter(task => {
      const taskDate = dayjs(task.createTime).startOf('day');
      return taskDate.isSame(today);
    });
  },
  
  /**
   * 本周任务
   */
  get thisWeekTasks() {
    const startOfWeek = dayjs().startOf('week');
    const endOfWeek = dayjs().endOf('week');
    
    return this.list.filter(task => {
      const taskDate = dayjs(task.createTime);
      return taskDate.isAfter(startOfWeek) && taskDate.isBefore(endOfWeek);
    });
  },
  
  /**
   * 任务完成率
   */
  get completionRate() {
    const total = this.list.length;
    if (total === 0) return 0;
    
    const completed = this.completedTasks.length;
    return Math.round((completed / total) * 100);
  },
  
  /**
   * 按优先级统计
   */
  get priorityStats() {
    const stats = {
      [PRIORITY_LEVEL.LOW]: 0,
      [PRIORITY_LEVEL.NORMAL]: 0,
      [PRIORITY_LEVEL.HIGH]: 0,
      [PRIORITY_LEVEL.URGENT]: 0
    };
    
    this.list.forEach(task => {
      const level = task.priorityLevel;
      if (stats[level] !== undefined) {
        stats[level]++;
      }
    });
    
    return stats;
  },
  
  /**
   * 按状态统计
   */
  get statusStats() {
    const stats = {
      [TASK_STATUS.PENDING]: 0,
      [TASK_STATUS.PROCESSING]: 0,
      [TASK_STATUS.COMPLETED]: 0,
      [TASK_STATUS.CANCELED]: 0
    };
    
    this.list.forEach(task => {
      const status = task.status;
      if (stats[status] !== undefined) {
        stats[status]++;
      }
    });
    
    return stats;
  },
  
  /**
   * 分页信息文本
   */
  get paginationText() {
    return `第${this.pagination.page}页 - 共${this.pagination.total}条`;
  },
  
  // ==== Action方法 ====
  
  /**
   * 初始化Store
   */
  init: action(function() {
    // 从缓存加载数据
    this.loadFromCache();
    
    // 设置自动刷新定时器
    this._setupAutoRefresh();
  }),
  
  /**
   * 重置状态
   */
  reset: action(function() {
    this.list = [];
    this.current = null;
    this.filter = {
      status: null,
      keyword: '',
      startDate: null,
      endDate: null,
      priorityLevel: null,
      assignee: null,
      category: null,
      dateRange: null,
      searchFields: ['title', 'description', 'tags', 'assigneeName']
    };
    this.sort = {
      field: 'createTime',
      order: 'desc'
    };
    this.pagination = {
      page: 1,
      size: 20,
      total: 0,
      hasMore: true
    };
    this.loading = {
      list: false,
      detail: false,
      submit: false,
      operation: false
    };
    this.error = null;
    
    // 清除自动刷新定时器
    this._clearAutoRefresh();
  }),
  
  /**
   * 设置加载状态
   */
  setLoading: action(function(key, status) {
    this.loading[key] = status;
  }),
  
  /**
   * 设置错误信息
   */
  setError: action(function(error) {
    this.error = error;
  }),
  
  /**
   * 设置过滤条件
   */
  setFilter: action(function(filter) {
    this.filter = { ...this.filter, ...filter };
    
    // 重置分页
    this.pagination.page = 1;
  }),
  
  /**
   * 设置排序
   */
  setSort: action(function(field, order) {
    this.sort = {
      field,
      order
    };
    
    // 重置分页
    this.pagination.page = 1;
  }),
  
  /**
   * 加载任务列表数据
   */
  loadList: action(async function(params = {}, reset = false) {
    try {
      // 检查是否正在加载
      if (this.loading.list) return;
      
      // 设置加载状态
      this.setLoading('list', true);
      this.setError(null);
      
      // 是否重置分页
      if (reset) {
        this.pagination.page = 1;
        this.pagination.hasMore = true;
      }
      
      // 检查是否还有更多数据
      if (!this.pagination.hasMore && !reset) {
        this.setLoading('list', false);
        return;
      }
      
      // 构建请求参数
      const requestParams = {
        page: this.pagination.page,
        size: this.pagination.size,
        sort: this.sort.field,
        order: this.sort.order,
        ...params
      };
      
      // 添加过滤条件
      if (this.filter.status !== null) {
        requestParams.status = this.filter.status;
      }
      
      if (this.filter.keyword) {
        requestParams.keyword = this.filter.keyword;
      }
      
      if (this.filter.priorityLevel !== null) {
        requestParams.priorityLevel = this.filter.priorityLevel;
      }
      
      if (this.filter.assignee) {
        requestParams.assignee = this.filter.assignee;
      }
      
      if (this.filter.category) {
        requestParams.category = this.filter.category;
      }
      
      // 处理日期范围
      if (this.filter.dateRange && this.filter.dateRange.length === 2) {
        requestParams.startDate = this.filter.dateRange[0];
        requestParams.endDate = this.filter.dateRange[1];
      }
      
      // 节流处理 - 避免短时间内重复请求
      // 如果在200ms内有相同参数的请求，则忽略
      const requestKey = JSON.stringify(requestParams);
      if (this._lastRequestKey === requestKey && 
          (dayjs().valueOf() - this._lastRequestTime) < 200) {
        this.setLoading('list', false);
        return;
      }
      
      this._lastRequestKey = requestKey;
      this._lastRequestTime = dayjs().valueOf();
      
      // 调用云函数
      const result = await cloudHelper.callCloudData(API.LIST, requestParams);
      
      // 处理返回结果
      if (result && result.list) {
        // 处理数据
        const newList = result.list.map(item => this._formatListItem(item));
        
        // 更新状态
        if (reset) {
          this.list = newList;
        } else {
          // 使用Set防止重复数据
          const uniqueItems = new Set([...this.list.map(i => i.id), ...newList.map(i => i.id)]);
          const combinedList = [...this.list];
          
          // 只添加不重复的新项目
          newList.forEach(newItem => {
            if (!this.list.some(item => item.id === newItem.id)) {
              combinedList.push(newItem);
            }
          });
          
          this.list = combinedList;
        }
        
        // 更新分页信息
        this.pagination.total = result.total || 0;
        this.pagination.hasMore = this.list.length < this.pagination.total;
        this.pagination.page++;
        
        // 更新缓存时间戳
        this.cache.lastUpdate = dayjs().valueOf();
        
        // 缓存数据
        this._cacheListData();
      }
      
      return this.list;
    } catch (error) {
      console.error('加载任务列表失败:', error);
      this.setError(error.message || '加载数据失败');
    } finally {
      this.setLoading('list', false);
    }
  }),
  
  /**
   * 加载任务详情数据
   */
  loadDetail: action(async function(id) {
    try {
      // 检查是否正在加载
      if (this.loading.detail) return;
      
      // 设置加载状态
      this.setLoading('detail', true);
      this.setError(null);
      
      // 先从列表中查找，如果有匹配项直接使用
      const taskInList = this.list.find(task => task.id === id);
      if (taskInList) {
        this.current = taskInList;
        this.setLoading('detail', false);
        return this.current;
      }
      
      // 如果列表中没有，再调用云函数
      const result = await cloudHelper.callCloudData(API.DETAIL, { id });
      
      // 处理返回结果
      if (result) {
        // 格式化数据
        this.current = this._formatDetailItem(result);
      }
      
      return this.current;
    } catch (error) {
      console.error('加载任务详情失败:', error);
      this.setError(error.message || '加载详情数据失败');
    } finally {
      this.setLoading('detail', false);
    }
  }),
  
  /**
   * 提交任务数据（添加/编辑）
   */
  submitTask: action(async function(data, isAdd = true) {
    try {
      // 检查是否正在提交
      if (this.loading.submit) return;
      
      // 设置加载状态
      this.setLoading('submit', true);
      this.setError(null);
      
      // 调用云函数
      const api = isAdd ? API.ADD : API.EDIT;
      const result = await cloudHelper.callCloudData(api, data);
      
      // 如果是添加操作，将新任务添加到列表
      if (isAdd && result) {
        const newTask = this._formatListItem(result);
        this.list = [newTask, ...this.list];
        
        // 更新缓存
        this._cacheListData();
      } 
      // 如果是编辑操作，更新列表中对应任务
      else if (!isAdd && result) {
        const updatedTask = this._formatListItem(result);
        this.list = this.list.map(task => 
          task.id === updatedTask.id ? updatedTask : task
        );
        
        // 如果当前任务是被编辑的任务，也更新当前任务
        if (this.current && this.current.id === updatedTask.id) {
          this.current = updatedTask;
        }
        
        // 更新缓存
        this._cacheListData();
      }
      
      return result;
    } catch (error) {
      console.error('提交任务失败:', error);
      this.setError(error.message || '提交数据失败');
    } finally {
      this.setLoading('submit', false);
    }
  }),
  
  /**
   * 删除任务
   */
  deleteTask: action(async function(id) {
    try {
      // 检查是否正在操作
      if (this.loading.operation) return;
      
      // 设置加载状态
      this.setLoading('operation', true);
      this.setError(null);
      
      // 调用云函数
      await cloudHelper.callCloudData(API.DELETE, { id });
      
      // 更新列表 - 移除已删除任务
      this.list = this.list.filter(task => task.id !== id);
      
      // 如果当前任务是被删除的任务，清空当前任务
      if (this.current && this.current.id === id) {
        this.current = null;
      }
      
      // 更新缓存
      this._cacheListData();
      
      return true;
    } catch (error) {
      console.error('删除任务失败:', error);
      this.setError(error.message || '删除数据失败');
      return false;
    } finally {
      this.setLoading('operation', false);
    }
  }),
  
  /**
   * 更新任务状态
   */
  updateTaskStatus: action(async function(id, status) {
    try {
      // 检查是否正在操作
      if (this.loading.operation) return;
      
      // 设置加载状态
      this.setLoading('operation', true);
      this.setError(null);
      
      // 调用云函数
      await cloudHelper.callCloudData(API.STATUS, { id, status });
      
      // 更新列表中对应任务的状态
      this.list = this.list.map(task => {
        if (task.id === id) {
          return {
            ...task,
            status,
            updateTime: dayjs().valueOf(),
            updateTimeFormatted: dayjs().format('YYYY-MM-DD HH:mm')
          };
        }
        return task;
      });
      
      // 如果当前任务是被更新的任务，也更新当前任务
      if (this.current && this.current.id === id) {
        this.current = {
          ...this.current,
          status,
          updateTime: dayjs().valueOf(),
          updateTimeFormatted: dayjs().format('YYYY-MM-DD HH:mm')
        };
      }
      
      // 更新缓存
      this._cacheListData();
      
      return true;
    } catch (error) {
      console.error('更新任务状态失败:', error);
      this.setError(error.message || '更新状态失败');
      return false;
    } finally {
      this.setLoading('operation', false);
    }
  }),
  
  /**
   * 从缓存加载数据
   */
  loadFromCache: action(function() {
    try {
      const cacheData = Cache.get(CACHE_KEY);
      
      if (cacheData) {
        // 设置数据
        this.list = cacheData.list || [];
        this.pagination = cacheData.pagination || this.pagination;
        this.filter = cacheData.filter || this.filter;
        this.sort = cacheData.sort || this.sort;
        this.cache.lastUpdate = cacheData.timestamp || dayjs().valueOf();
        
        // 检查缓存是否已过期
        if (Cache.isExpired(CACHE_KEY)) {
          // 缓存已过期，标记需要刷新
          this.cache.isExpired = true;
          
          // 后台自动刷新数据，但不阻塞UI
          setTimeout(() => {
            this.loadList({}, true);
          }, 100);
        }
        
        return true;
      }
      
      return false;
    } catch (error) {
      console.error('从缓存加载数据失败:', error);
      return false;
    }
  }),
  
  /**
   * 刷新数据
   */
  refresh: action(async function() {
    // 重置分页
    this.pagination.page = 1;
    this.pagination.hasMore = true;
    
    // 加载数据
    return await this.loadList({}, true);
  }),
  
  /**
   * 加载更多数据
   */
  loadMore: action(async function() {
    // 检查是否还有更多数据
    if (!this.pagination.hasMore || this.loading.list) {
      return;
    }
    
    // 加载下一页
    return await this.loadList();
  }),
  
  /**
   * 加载任务列表数据 (兼容旧方法名)
   */
  loadTasks: action(function(params = {}, reset = true) {
    return this.loadList(params, reset);
  }),
  
  /**
   * 根据关键词搜索任务
   */
  searchTask: action(function(keyword) {
    this.filter.keyword = keyword || '';
    return this.loadList({}, true);
  }),
  
  /**
   * 导航到任务详情页
   */
  navigateToTask: action(function(taskId) {
    if (!taskId) return;
    
    // 导航到任务详情页
    wx.navigateTo({
      url: `/projects/oa/pages/task/detail/task_detail?id=${taskId}`
    });
  }),
  
  /**
   * 创建新任务
   */
  createTask: action(function() {
    // 导航到创建任务页面
    wx.navigateTo({
      url: '/projects/oa/pages/task/edit/task_edit'
    });
  }),
  
  // ==== 内部辅助方法 ====
  
  /**
   * 缓存列表数据
   */
  _cacheListData: function() {
    const cacheData = {
      list: this.list,
      pagination: this.pagination,
      filter: this.filter,
      sort: this.sort,
      timestamp: dayjs().valueOf()
    };
    
    Cache.set(CACHE_KEY, cacheData, CACHE_TIME);
  },
  
  /**
   * 格式化列表项
   */
  _formatListItem: function(item) {
    const now = dayjs();
    const createTime = item.createTime || item.CREATE_TIME || now;
    const updateTime = item.updateTime || item.UPDATE_TIME || createTime;
    
    return {
      id: item._id || item.id,
      title: item.title || '',
      description: item.description || '',
      status: item.status === undefined ? TASK_STATUS.PENDING : item.status,
      priorityLevel: item.priorityLevel === undefined ? PRIORITY_LEVEL.NORMAL : item.priorityLevel,
      assignee: item.assignee || '',
      assigneeName: item.assigneeName || '',
      category: item.category || '',
      tags: item.tags || [],
      createTime: createTime,
      updateTime: updateTime,
      deadline: item.deadline || null,
      progress: item.progress || 0,
      attachments: item.attachments || [],
      comments: item.comments || [],
      // 格式化时间
      createTimeFormatted: dayjs(createTime).format('YYYY-MM-DD HH:mm'),
      updateTimeFormatted: dayjs(updateTime).format('YYYY-MM-DD HH:mm'),
      deadlineFormatted: item.deadline ? dayjs(item.deadline).format('YYYY-MM-DD') : '',
      // 状态文本
      statusText: this._getStatusText(item.status),
      // 优先级文本
      priorityText: this._getPriorityText(item.priorityLevel),
      // 是否逾期
      isOverdue: item.deadline ? dayjs(item.deadline).isBefore(now) : false,
      // 剩余天数
      daysLeft: item.deadline ? Math.max(0, dayjs(item.deadline).diff(now, 'day')) : null
    };
  },
  
  /**
   * 格式化详情项
   */
  _formatDetailItem: function(item) {
    // 使用相同的格式化逻辑
    return this._formatListItem(item);
  },
  
  /**
   * 获取状态文本
   */
  _getStatusText: function(status) {
    const statusMap = {
      [TASK_STATUS.PENDING]: '待处理',
      [TASK_STATUS.PROCESSING]: '处理中',
      [TASK_STATUS.COMPLETED]: '已完成',
      [TASK_STATUS.CANCELED]: '已取消'
    };
    
    return statusMap[status] || '未知状态';
  },
  
  /**
   * 获取优先级文本
   */
  _getPriorityText: function(level) {
    const priorityMap = {
      [PRIORITY_LEVEL.LOW]: '低',
      [PRIORITY_LEVEL.NORMAL]: '中',
      [PRIORITY_LEVEL.HIGH]: '高',
      [PRIORITY_LEVEL.URGENT]: '紧急'
    };
    
    return priorityMap[level] || '未知';
  },
  
  /**
   * 设置自动刷新定时器
   */
  _setupAutoRefresh: function() {
    // 清除旧的定时器
    this._clearAutoRefresh();
    
    // 创建新的定时器
    this._autoRefreshTimer = setInterval(() => {
      // 如果有数据且未处于加载状态，自动刷新
      if (this.list.length > 0 && !this.isLoading) {
        // 悄悄刷新，不显示加载状态
        this.refresh().catch(err => {
          console.error('自动刷新失败:', err);
        });
      }
    }, this.cache.autoRefreshInterval);
  },
  
  /**
   * 清除自动刷新定时器
   */
  _clearAutoRefresh: function() {
    if (this._autoRefreshTimer) {
      clearInterval(this._autoRefreshTimer);
      this._autoRefreshTimer = null;
    }
  }
}); 